home *** CD-ROM | disk | FTP | other *** search
/ Aminet 24 / Aminet 24 (1998)(GTI - Schatztruhe)[!][Apr 1998].iso / Aminet / dev / c / AmiVoGL_MDEV.lha / src / queue.c < prev    next >
C/C++ Source or Header  |  1994-08-06  |  8KB  |  402 lines
  1. #include <stdio.h>
  2. #include "vogl.h"
  3. #include "vodevice.h"
  4.  
  5. /*
  6.  * qdevice
  7.  *
  8.  *    enable an input device.
  9.  */
  10. void qdevice(Device dev)
  11. {
  12. int    i;
  13.  
  14.  
  15. if (!vdevice.initialised)
  16. verror("qdevice: vogl not initialised\n");
  17.  
  18. if (dev > (Device)MAXDEV)
  19. verror("qdevice: bad device number passed\n");
  20.  
  21. switch (dev) {
  22. case AKEY:
  23. case BKEY:
  24. case CKEY:
  25. case DKEY:
  26. case EKEY:
  27. case FKEY:
  28. case GKEY:
  29. case HKEY:
  30. case IKEY:
  31. case JKEY:
  32. case KKEY:
  33. case LKEY:
  34. case MKEY:
  35. case NKEY:
  36. case OKEY:
  37. case PKEY:
  38. case QKEY:
  39. case RKEY:
  40. case SKEY:
  41. case TKEY:
  42. case UKEY:
  43. case VKEY:
  44. case WKEY:
  45. case XKEY:
  46. case YKEY:
  47. case ZKEY:
  48.     vdevice.kbdevents = 1;
  49.     vdevice.enabled[dev / 8] |= 1 << (dev & 0x7);
  50.     vdevice.enabled[(dev - 'A' + 'a') / 8] |= 1 << ((dev - 'A' + 'a') & 0x7);
  51.     break;
  52. case KEYBD:
  53.     vdevice.kbdmode = 1;
  54.     vdevice.kbdevents = 1;
  55.     for (i = 0; i != MAXDEVTABSIZE; i++)
  56.     vdevice.enabled[i] = 0xff;
  57.  
  58.     vdevice.enabled[0] &= 0xfe;    /* make sure 0 disabled for qtest */
  59.     break;
  60. case MOUSE1:
  61. case MOUSE2:
  62. case MOUSE3:
  63.     vdevice.mouseevents = 1;
  64.     vdevice.enabled[dev / 8] |= 1 << (dev & 0x7);
  65.     break;
  66. case MINUSKEY:
  67.     vdevice.kbdevents = 1;
  68.     vdevice.enabled['-' / 8] |= 1 << ('-' & 0x7);
  69.     vdevice.enabled['_' / 8] |= 1 << ('_' & 0x7);
  70.     break;
  71. case BACKSLASHKEY:
  72.     vdevice.kbdevents = 1;
  73.     vdevice.enabled['\\' / 8] |= 1 << ('\\' & 0x7);
  74.     vdevice.enabled['|' / 8] |= 1 << ('|' & 0x7);
  75.     break;
  76. case EQUALKEY:
  77.     vdevice.kbdevents = 1;
  78.     vdevice.enabled['=' / 8] |= 1 << ('=' & 0x7);
  79.     vdevice.enabled['+' / 8] |= 1 << ('+' & 0x7);
  80.     break;
  81. case LEFTBRACKETKEY:
  82.     vdevice.kbdevents = 1;
  83.     vdevice.enabled['[' / 8] |= 1 << ('[' & 0x7);
  84.     vdevice.enabled['{' / 8] |= 1 << ('{' & 0x7);
  85.     break;
  86. case RIGHTBRACKETKEY:
  87.     vdevice.kbdevents = 1;
  88.     vdevice.enabled[']' / 8] |= 1 << (']' & 0x7);
  89.     vdevice.enabled['}' / 8] |= 1 << ('}' & 0x7);
  90.     break;
  91. case REDRAW:        /* do nothing */
  92. case INPUTCHANGE:
  93.     break;
  94. default:
  95.     vdevice.kbdevents = 1;
  96.     vdevice.enabled[dev / 8] |= 1 << (dev & 0x7);
  97.     }
  98.  
  99. }
  100.  
  101. /* ------------------------------------------------------------------------ */
  102.  
  103. /*
  104.  * unqdevice
  105.  *
  106.  *    disable an input device.
  107.  */
  108. void unqdevice(Device dev)
  109. {
  110. int    i;
  111.  
  112.  
  113. if (!vdevice.initialised)
  114. verror("qdevice: vogl not initialised\n");
  115.  
  116. if (dev > (Device)MAXDEV)
  117. verror("qdevice: bad device number passed\n");
  118.  
  119. switch (dev) {
  120. case AKEY:
  121. case BKEY:
  122. case CKEY:
  123. case DKEY:
  124. case EKEY:
  125. case FKEY:
  126. case GKEY:
  127. case HKEY:
  128. case IKEY:
  129. case JKEY:
  130. case KKEY:
  131. case LKEY:
  132. case MKEY:
  133. case NKEY:
  134. case OKEY:
  135. case PKEY:
  136. case QKEY:
  137. case RKEY:
  138. case SKEY:
  139. case TKEY:
  140. case UKEY:
  141. case VKEY:
  142. case WKEY:
  143. case XKEY:
  144. case YKEY:
  145. case ZKEY:
  146.     vdevice.enabled[dev / 8] &= ~(1 << (dev & 0x7));
  147.     vdevice.enabled[(dev - 'A' + 'a') / 8] &= ~(1 << ((dev - 'A' + 'a') & 0x7));
  148.     break;
  149. case KEYBD:
  150.     vdevice.kbdmode = 0;
  151.     for (i = 0; i != MAXDEVTABSIZE; i++)
  152.     vdevice.enabled[i] = 0x00;
  153.     break;
  154. case MOUSE1:
  155. case MOUSE2:
  156. case MOUSE3:
  157.     vdevice.enabled[dev / 8] &= ~(1 << (dev & 0x7));
  158.     break;
  159. case MINUSKEY:
  160.     vdevice.enabled['-' / 8] &= ~(1 << ('-' & 0x7));
  161.     vdevice.enabled['_' / 8] &= ~(1 << ('_' & 0x7));
  162.     break;
  163. case BACKSLASHKEY:
  164.     vdevice.enabled['\\' / 8] &= ~(1 << ('\\' & 0x7));
  165.     vdevice.enabled['|' / 8] &= ~(1 << ('|' & 0x7));
  166.     break;
  167. case EQUALKEY:
  168.     vdevice.enabled['=' / 8] &= ~(1 << ('=' & 0x7));
  169.     vdevice.enabled['+' / 8] &= ~(1 << ('+' & 0x7));
  170.     break;
  171. case LEFTBRACKETKEY:
  172.     vdevice.enabled['[' / 8] &= ~(1 << ('[' & 0x7));
  173.     vdevice.enabled['{' / 8] &= ~(1 << ('{' & 0x7));
  174.     break;
  175. case RIGHTBRACKETKEY:
  176.     vdevice.enabled[']' / 8] &= ~(1 << (']' & 0x7));
  177.     vdevice.enabled['}' / 8] &= ~(1 << ('}' & 0x7));
  178.     break;
  179. case REDRAW:        /* do nothing */
  180. case INPUTCHANGE:
  181.     return;
  182. default:
  183.     vdevice.enabled[dev / 8] &= ~(1 << (dev & 0x7));
  184.     }
  185.  
  186. vdevice.mouseevents = vdevice.kbdevents = 0;
  187.  
  188. for (i = 0; i != MAXDEVTABSIZE; i++)
  189. if (vdevice.enabled[i] != 0) {
  190.     if (i < 32)        /* max bits for keyboard */
  191.     vdevice.kbdevents = 1;
  192.     else                /* must be mouse */
  193.     vdevice.mouseevents = 1;
  194.     }
  195. }
  196.  
  197. /* ------------------------------------------------------------------------ */
  198.  
  199. /*
  200.  * qread
  201.  *
  202.  *    a poor man's qread, we only have a device queue one deep.
  203.  * Just sit and poll in case something happens. If nothing is
  204.  * enabled or there are no devices this returns -1.
  205.  */
  206. long qread(short *ret)
  207. {
  208. int    a, b, c1, c2, val;
  209. int    eventind, eventmask, retvalue;
  210.  
  211.  
  212. if (!vdevice.initialised) verror("qread: vogl not initialised\n");
  213.  
  214. if (vdevice.alreadyread) {
  215.  
  216.     *ret = vdevice.data;
  217.     if (!vdevice.kbdmode && vdevice.data == 1) vdevice.data        = 0;
  218.     else                                       vdevice.alreadyread = 0;
  219.     return vdevice.devno;
  220.     }
  221.  
  222. val = c1 = c2 = 0;
  223.  
  224. eventind  = 0;
  225. eventmask = 0;
  226.  
  227. if (!vdevice.mouseevents && vdevice.kbdevents) {
  228.     while (!(vdevice.enabled[eventind] & eventmask)) {
  229.         if ((val = c1 = (*vdevice.dev.Vgetkey)()) < 0) {
  230.             return(val);
  231.             }
  232.  
  233.         eventind = c1 / 8;
  234.         eventmask = 1 << (c1 & 0x7);
  235.         *ret = c1;
  236.         if (c1 >= 'a' && c1 <= 'z') retvalue = c1 - 'a' + 'A';
  237.         else                        retvalue = c1;
  238.         }
  239.     }
  240. else if (vdevice.mouseevents && !vdevice.kbdevents) {
  241.     while (!(vdevice.enabled[eventind] & eventmask)) {
  242.         if ((c2 = (*vdevice.dev.Vlocator)(&a, &b)) < 0) {
  243.             return(c2);
  244.             }
  245.  
  246.         if (c2 != 0) {
  247.             if      (c2 & 0x01) c2 = MOUSE3;
  248.             else if (c2 & 0x02) c2 = MOUSE2;
  249.             else if (c2 & 0x04) c2 = MOUSE1;
  250.  
  251.             eventind  = c2 / 8;
  252.             eventmask = 1 << (c2 & 0x7);
  253.             *ret      = c2;
  254.             retvalue  = c2;
  255.             }
  256.         }
  257.     }
  258. else if (vdevice.mouseevents && vdevice.kbdevents) {
  259.     while (!(vdevice.enabled[eventind] & eventmask)) {
  260.         while (c1 == 0 && c2 == 0) {
  261.             val = c1 = (*vdevice.dev.Vcheckkey)();
  262.  
  263.             c2 = (*vdevice.dev.Vlocator)(&a, &b);
  264.             }
  265.  
  266.         if (c1 < 0 && c2 < 0) {
  267.             return(-1);
  268.             }
  269.  
  270.         if (c1 != 0) {
  271.             eventind  = c1 / 8;
  272.             eventmask = 1 << (c1 & 0x7);
  273.             *ret      = c1;
  274.             if (c1 >= 'a' && c1 <= 'z') retvalue = c1 - 'a' + 'A';
  275.             else                        retvalue = c1;
  276.             }
  277.         else {
  278.             if      (c2 & 0x01) c2 = MOUSE3;
  279.             else if (c2 & 0x02) c2 = MOUSE2;
  280.             else if (c2 & 0x04) c2 = MOUSE1;
  281.             eventind  = c2 / 8;
  282.             eventmask = 1 << (c2 & 0x7);
  283.             *ret      = c2;
  284.             retvalue  = c2;
  285.             }
  286.         }
  287.     }
  288. else {
  289.     return(-1);
  290.     }
  291.  
  292. if (vdevice.kbdmode && val != 0) {
  293.     *ret = val;
  294.     return(KEYBD);
  295.     }
  296. else {
  297.     *ret                = 1;            /* insert the up event */
  298.     vdevice.data        = 0;
  299.     vdevice.devno       = retvalue;
  300.     vdevice.alreadyread = 1;
  301.     }
  302.  
  303. return(retvalue);
  304. }
  305.  
  306. /* ------------------------------------------------------------------------ */
  307.  
  308. /*
  309.  * qreset
  310.  *
  311.  *    as the queue is rather short this is easy.
  312.  */
  313. void qreset(void)
  314. {
  315. while (((*vdevice.dev.Vcheckkey)()))
  316. ;
  317.  
  318. vdevice.alreadyread = 0;
  319. }
  320.  
  321. /* ------------------------------------------------------------------------ */
  322.  
  323. /*
  324.  * qtest
  325.  *
  326.  *    Check if there is anything in the event queue. As our reads are
  327.  * destructive at the moment, we have to save what we get in the device
  328.  * structure.
  329.  */
  330. long qtest(void)
  331. {
  332. int    a, b, c1, c2, val;
  333. int    eventind, eventmask;
  334.  
  335.  
  336. if (!vdevice.initialised) verror("qtest: vogl not initialised\n");
  337.  
  338. eventind  = 0;
  339. eventmask = 0;
  340. val       = c1 = (*vdevice.dev.Vcheckkey)();
  341. c2        = (*vdevice.dev.Vlocator)(&a, &b);
  342.  
  343. if (c1 != 0) {
  344.     eventind  = c1 / 8;
  345.     eventmask = 1 << (c1 & 0x7);
  346.     if (vdevice.kbdmode) {
  347.         vdevice.data  = val;
  348.         vdevice.devno = KEYBD;
  349.         }
  350.     else {
  351.         vdevice.data = 1;
  352.         if (c1 >= 'a' && c1 <= 'z') vdevice.devno = c1 - 'a' + 'A';
  353.         else                        vdevice.devno = c1;
  354.         }
  355.     }
  356. else {
  357.     if      (c2 & 0x01) c2 = MOUSE3;
  358.     else if (c2 & 0x02) c2 = MOUSE2;
  359.     else if (c2 & 0x04) c2 = MOUSE1;
  360.     eventind      = c2 / 8;
  361.     eventmask     = 1 << (c2 & 0x7);
  362.     vdevice.data  = 1;
  363.     vdevice.devno = c2;
  364.     }
  365.  
  366.  
  367. if (vdevice.enabled[eventind] & eventmask) {
  368.     vdevice.alreadyread = 1;
  369.     return 1L;
  370.     }
  371.  
  372. return 0L;
  373. }
  374.  
  375. /* ------------------------------------------------------------------------ */
  376.  
  377. /*
  378.  * isqueued
  379.  *
  380.  *    return non-zero if a device is queued
  381.  */
  382. Boolean isqueued(Device dev)
  383. {
  384. return((long)vdevice.enabled[dev / 8] & (1 << (dev & 0x7)));
  385. }
  386.  
  387. /* ------------------------------------------------------------------------ */
  388.  
  389. /*
  390.  * qenter
  391.  *
  392.  *    Basically, does nothing....
  393.  */
  394. void qenter(
  395.   Device dev,
  396.   short val)
  397. {
  398. }
  399.  
  400. /* ------------------------------------------------------------------------ */
  401.  
  402.